home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / InstallInk < prev    next >
Text File  |  1992-08-11  |  19KB  |  931 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Port.h"
  6.  
  7. #include "Class.h"
  8. #include "String.h"
  9. #include "Error.h"
  10. #include "Picture.h"
  11. #include "WindowSystem.h"
  12. #include "DevBitmap.h"
  13. #include "Math.h"
  14.  
  15. Port *Port::port, *Port::tbport;
  16. Ink *Port::tbink= 0;
  17. Point Port::tbpos, Port::tblastpos;
  18. Rectangle Port::tbbbox;
  19.  
  20. static inline void ScaleRect(Port *p, Rectangle &r)
  21. {
  22.     if (p->scale & 1) {
  23.     r.origin.x= (int) ((float)r.origin.x * p->scalex + 0.5);
  24.     r.origin.y= (int) ((float)r.origin.y * p->scaley + 0.5);
  25.     r.extent.x= (int) ((float)r.extent.x * p->scalex + 0.5);
  26.     r.extent.y= (int) ((float)r.extent.y * p->scaley + 0.5);
  27.     }
  28. }
  29.  
  30. static inline void ScalePoint(Port *port, Point &p)
  31. {
  32.     if (port->scale & 1) {
  33.     p.x= (int) ((float)p.x * port->scalex + 0.5);
  34.     p.y= (int) ((float)p.y * port->scaley + 0.5);
  35.     }
  36. }
  37.  
  38. static inline void ScaleInt(Port *p, int &i)
  39. {
  40.     if (p->scale & 1)
  41.     i= (int) ((float)i * p->scalex + 0.5);
  42. }
  43.  
  44. GrState::GrState(Port *p)
  45. {
  46.     if (p == 0)
  47.     port= Port::port;
  48.     else
  49.     port= p;
  50.     clip= port->cliprect;
  51.     origin= port->origin;
  52.     scalex= port->scalex;
  53.     scaley= port->scaley;
  54. }
  55.  
  56. GrState::~GrState()
  57. {
  58.     port->FlushMyText();
  59.     port->sfont= 0;
  60.     port->DevScale(scalex, scaley);
  61.     port->origin= origin;
  62.     port->Clip(clip);
  63. }
  64.  
  65. //---- Port --------------------------------------------------------------------
  66.  
  67. NewMetaImpl(Port,SysEvtHandler, (T(depth), T(hascolor)));
  68.  
  69. Port::Port() : SysEvtHandler(-1)
  70. {
  71.     PortInit();
  72.     hascolor= FALSE;
  73.     depth= gDepth;
  74. }
  75.  
  76. Port::~Port()
  77. {
  78.     if (port == this)
  79.     port= 0;
  80.     if (tbport == this)
  81.     tbport= 0;
  82. }
  83.  
  84. void Port::PortInit()
  85. {
  86.     scalex= scaley= 1.0;
  87.     scale= FALSE;
  88.     cliprect= Rectangle(0, 0, 30000, 30000);
  89.     origin= gPoint0;
  90.     SetNormal();
  91.     SetPenNormal();
  92.     SetTextNormal();
  93. }
  94.  
  95. //---- abstract cursor methods -------------------------------------------------
  96.  
  97. GrCursor Port::SetCursor(GrCursor c)
  98. { 
  99.     return c;
  100. }
  101.  
  102. GrCursor Port::SetWaitCursor(unsigned int, GrCursor c)
  103. {
  104.     if (this)
  105.     return SetCursor(c);
  106.     return c;
  107. }
  108.  
  109. GrCursor Port::GetCursor()
  110. {
  111.     return eCrsNone;
  112. }
  113.  
  114. //---- graphics context --------------------------------------------------------
  115.  
  116. void Port::SetPenNormal()
  117. {
  118.     pensize= 1;
  119.     penink= gInkBlack;
  120.     pencap= eDefaultCap;
  121. }
  122.  
  123. void Port::SetTextNormal()
  124. {
  125.     textink= gInkBlack;
  126.     textfont= gSysFont;
  127. }
  128.  
  129. //---- color halftoning (ordered dither) ---------------------------------------
  130.  
  131. extern Ink *Grey2Halftone(float f);
  132.  
  133. void Port::DevSetGrey(float f)
  134. {
  135.     InstallInk(Grey2Halftone(f));
  136. }
  137.  
  138. void Port::SetColor(RGBColor *cp)
  139. {
  140.     if (HasColor())
  141.     DevSetColor(cp);
  142.     else
  143.     DevSetGrey(cp->AsGreyLevel() / 255.0);
  144. }
  145.  
  146. //---- clipping ----------------------------------------------------------------
  147.  
  148. void Port::InitClip()
  149. {
  150.     FlushMyText();
  151.     sfont= 0;
  152.     DevScale(1.0, 1.0);
  153.     cliprect= Rectangle(0, 0, 30000, 30000);
  154.     DevClip(cliprect);
  155.     origin= gPoint0;
  156. }
  157.  
  158. void Port::Clip(Rectangle r)
  159. {
  160.     if (cliprect != r) {
  161.     FlushMyText();
  162.     cliprect= r;
  163.     DevClip(cliprect);
  164.     // scale|= 2;
  165.     }
  166. }
  167.  
  168. void Port::ClipFurther(Rectangle r)
  169. {
  170.     ScaleRect(this, r);
  171.     r.origin+= origin;
  172.     r.Clip(cliprect);
  173.     Clip(r);
  174. }
  175.  
  176. void Port::Scale(float x, float y)
  177. {
  178.     FlushMyText();
  179.     sfont= 0;
  180.     DevScale(x*scalex, y*scaley);
  181. }
  182.  
  183. void Port::Translate(Point o)
  184. {
  185.     ScalePoint(this, o);
  186.     origin+= o;
  187. }
  188.  
  189. bool Port::Visible(Ink *ink, Rectangle &r)
  190. {
  191.     if (ink != gInkNone && (WindowSystem::fullscreen || cliprect.Intersects(r))) {
  192.     if (scale & 2) {
  193.         DevClip(cliprect);
  194.         scale&= ~2;
  195.     }
  196.     FlushMyText();
  197.     InstallInk(ink);
  198.     return TRUE;
  199.     }
  200.     return FALSE;
  201. }
  202.  
  203. //---- graphic primitives ------------------------------------------------------
  204.  
  205. void Port::StrokeLine(Ink *ink, int psz, GrLineCap cap, Point p1, Point p2)
  206. {
  207.     if (ignore)
  208.     return;
  209.     if (scale & 1) {
  210.     ScalePoint(this, p1);
  211.     ScalePoint(this, p2);
  212.     ScaleInt(this, psz);
  213.     }
  214.     p1+= origin;
  215.     p2+= origin;
  216.     Rectangle rr= NormRect(p1,p2).Expand(Math::Max(2, psz)/2);
  217.     if (Visible(ink, rr))
  218.     DevStrokeLine(psz, &rr, cap, p1, p2);
  219. }
  220.  
  221. void Port::StrokeRect(Ink *ink, int psz, Rectangle r)
  222. {
  223.     if (ignore)
  224.     return;
  225.     if (scale & 1) {
  226.     ScaleRect(this, r);
  227.     ScaleInt(this, psz);
  228.     }
  229.     r.origin+= origin;
  230.     if (Visible(ink, r))
  231.     DevStrokeRect(psz, &r);
  232. }
  233.  
  234. void Port::FillRect(Ink *ink, Rectangle r)
  235. {
  236.     if (ignore)
  237.     return;
  238.     ScaleRect(this, r);
  239.     r.origin+= origin;
  240.     if (Visible(ink, r))
  241.     DevFillRect(&r);
  242. }
  243.  
  244. void Port::StrokeOval(Ink *ink, int psz, Rectangle r)
  245. {
  246.     if (ignore)
  247.     return;
  248.     if (scale & 1) {
  249.     ScaleRect(this, r);
  250.     ScaleInt(this, psz);
  251.     }
  252.     r.origin+= origin;
  253.     if (Visible(ink, r))
  254.     DevStrokeOval(psz, &r);
  255. }
  256.  
  257. void Port::FillOval(Ink *ink, Rectangle r)
  258. {
  259.     if (ignore)
  260.     return;
  261.     ScaleRect(this, r);
  262.     r.origin+= origin;
  263.     if (Visible(ink, r))
  264.     DevFillOval(&r);
  265. }
  266.  
  267. void Port::StrokeRRect(Ink *ink, int psz, Rectangle r, Point dia)
  268. {
  269.     if (ignore)
  270.     return;
  271.     if (scale & 1) {
  272.     ScaleRect(this, r);
  273.     ScalePoint(this, dia);
  274.     ScaleInt(this, psz);
  275.     }
  276.     r.origin+= origin;
  277.     if (Visible(ink, r))
  278.     DevStrokeRRect(psz, &r, dia);
  279. }
  280.  
  281. void Port::FillRRect(Ink *ink, Rectangle r, Point dia)
  282. {
  283.     if (ignore)
  284.     return;
  285.     if (scale & 1) {
  286.     ScaleRect(this, r);
  287.     ScalePoint(this, dia);
  288.     }
  289.     r.origin+= origin;
  290.     if (Visible(ink, r))
  291.     DevFillRRect(&r, dia);
  292. }
  293.  
  294. void Port::StrokeWedge(Ink *ink, int psz, GrLineCap cap, Rectangle r, int s, int l)
  295. {
  296.     if (ignore)
  297.     return;
  298.     if (l >= 360) {
  299.     StrokeOval(ink, psz, r);
  300.     return;
  301.     }
  302.     while (s < 0)
  303.     s+= 360;
  304.     while (s >= 360)
  305.     s-= 360;
  306.     if (scale & 1) {
  307.     ScaleRect(this, r);
  308.     ScaleInt(this, psz);
  309.     }
  310.     r.origin+= origin;
  311.     if (Visible(ink, r.WedgeBBox(s, l)))
  312.     DevStrokeWedge(psz, cap, &r, s, l);
  313. }
  314.  
  315. void Port::FillWedge(Ink *ink, Rectangle r, int s, int l)
  316. {
  317.     if (ignore)
  318.     return;
  319.     if (l >= 360) {
  320.     FillOval(ink, r);
  321.     return;
  322.     }
  323.     while (s < 0)
  324.     s+= 360;
  325.     while (s >= 360)
  326.     s-= 360;
  327.     ScaleRect(this, r);
  328.     r.origin+= origin;
  329.     if (Visible(ink, r.WedgeBBox(s, l)))
  330.     DevFillWedge(&r, s, l);
  331. }
  332.  
  333. void Port::StrokePolygon(Point at, Ink *ink, Point *pts,
  334.                 int npts, GrPolyType t, int psz, GrLineCap cap)
  335. {
  336.     if (ignore)
  337.     return;
  338.     if (pts && npts > 0) {
  339.     Point *p= (Point*) Alloca(npts * sizeof(Point));
  340.     Rectangle r(BoundingBox(npts, pts, p));
  341.     r.origin+= at;
  342.     if (scale & 1) {
  343.         ScaleRect(this, r);
  344.         ScaleInt(this, psz);
  345.         for (int i= 0; i < npts; i++)
  346.         ScalePoint(this, p[i]);
  347.     }
  348.     r.origin+= origin;
  349.     if (Visible(ink, r))
  350.         DevStrokePolygon(&r, p, npts, t, psz, cap);
  351.     Freea(p);
  352.     }
  353. }
  354.  
  355. void Port::FillPolygon(Point at, Ink *ink, Point *pts, int npts, GrPolyType t)
  356. {
  357.     if (ignore)
  358.     return;
  359.     if (pts && npts > 0) {
  360.     Point *p= (Point*) Alloca(npts * sizeof(Point));
  361.     Rectangle r= BoundingBox(npts, pts, p);
  362.     r.origin+= at;
  363.     if (scale & 1) {
  364.         ScaleRect(this, r);
  365.         for (int i= 0; i < npts; i++)
  366.         ScalePoint(this, p[i]);
  367.     }
  368.     r.origin+= origin;
  369.     if (Visible(ink, r))
  370.         DevFillPolygon(&r, p, npts, t);
  371.     Freea(p);
  372.     }
  373. }
  374.  
  375. void Port::ShowBitmap(Ink *ink, Rectangle r, Bitmap *bm)
  376. {
  377.     if (ignore)
  378.     return;
  379.     ScaleRect(this, r);
  380.     r.origin+= origin;
  381.     if (Visible(ink, r))
  382.     DevShowBitmap(&r, bm);
  383. }
  384.  
  385. void Port::ShowPicture(Rectangle r, Picture *pic)
  386. {
  387.     if (ignore || pic == 0)
  388.     return;
  389.     ScaleRect(this, r);
  390.     r.origin+= origin;
  391.     if (Visible(gInkBlack, r))
  392.     DevShowPicture(&r, pic);
  393. }
  394.  
  395. void Port::GiveHint(int code, int len, void *vp)
  396. {
  397.     Rectangle r;
  398.     
  399.     if (vp && len < 0)
  400.     len= strlen((const char*) vp) + 1;
  401.     
  402.     switch (code) {
  403.  
  404.     case eHintBatch:
  405.     r= *((Rectangle*) vp);
  406.     ScaleRect(this, r);
  407.     r.origin+= origin;
  408.     DevGiveHint(code, len, &r);
  409.     break;
  410.     
  411.     default:
  412.     DevGiveHint(code, len, vp);
  413.     break;
  414.     }
  415. }
  416.  
  417. //---- Text ---------------------------------------------------------------------
  418.  
  419. void Port::SetFamily(GrFont fid)
  420. {
  421.     textfont= new_Font(fid, textfont->Size(), textfont->Face());
  422.     sfont= 0;
  423. }
  424.  
  425. void Port::SetSize(int ps)
  426. {
  427.     textfont= new_Font(textfont->Fid(), ps, textfont->Face());
  428.     sfont= 0;
  429. }
  430.  
  431. void Port::SetFace(GrFace face)
  432. {
  433.     textfont= new_Font(textfont->Fid(), textfont->Size(), face);
  434.     sfont= 0;
  435. }
  436.  
  437. void Port::SetFont(Font *fd)
  438. {
  439.     if (textfont != fd) {
  440.     textfont= fd;
  441.     sfont= 0;
  442.     }
  443. }
  444. //---- text batch --------------------------------------------------------------
  445.  
  446. void Port::flushtext()
  447. {
  448.     if (scale & 2) {
  449.     DevClip(cliprect);
  450.     scale&= ~2;
  451.     }
  452.     InstallInk(tbink);
  453.     DevShowTextBatch(&tbbbox, tbpos+origin);
  454.     tbport= 0;
  455. }
  456.  
  457. int Port::ShowChar(Font *fdp, Ink *ink, Point pos, byte c)
  458. {
  459.     byte s[2];
  460.     s[0]= c;
  461.     s[1]= 0;
  462.     return ShowString(fdp, ink, pos, s, 1);
  463. }
  464.  
  465. Ink *gTbInk;
  466.  
  467. int Port::ShowString(Font *fdp, Ink *ink, Point pos, byte *s, int l)
  468. {
  469.     Rectangle rr;
  470.     register int w, sl= 0;
  471.     byte c, *ss= s;
  472.     int ll= l;
  473.  
  474.     if (ignore || s == 0)
  475.     return 0;
  476.  
  477.     if (fdp != lastfdp) {
  478.     lastfdp= fdp;
  479.     sfont= 0;
  480.     }
  481.     
  482.     if (scale & 1) {
  483.     if (sfont == 0) {
  484.         int ss= fdp->Size();
  485.         ScaleInt(this, ss);
  486.         sfont= new_Font(fdp->Fid(), ss, fdp->Face());
  487.     }
  488.     fdp= sfont;
  489.     ScalePoint(this, pos);
  490.     }
  491.     
  492.     rr.origin= pos;
  493.     rr.origin+= origin;
  494.     rr.origin.y-= fdp->Ascender();
  495.     rr.extent.y= fdp->Spacing();
  496.  
  497.     while (l-- && (c= *s++)) {
  498.     rr.extent.x= w= fdp->Width(c);
  499.     if (WindowSystem::fullscreen || cliprect.Intersects(rr)) {
  500.         if (scale & 2) {
  501.         DevClip(cliprect);
  502.         scale&= ~2;
  503.         }
  504.         if (this != tbport || ink != tbink)
  505.         FlushAnyText();
  506.         gTbInk= ink;
  507.         DevShowChar(fdp, pos-tblastpos, c, &rr);
  508.         if (tbport == 0) {
  509.         tbport= this;
  510.         tbink= ink;
  511.         tbpos= pos;
  512.         tbbbox= rr;
  513.         } else
  514.         tbbbox.Merge(rr);
  515.         tblastpos.x= pos.x + w;
  516.         tblastpos.y= pos.y;
  517.     }
  518.     rr.origin.x+= w;
  519.     pos.x+= w;
  520.     sl+= w;
  521.     }
  522.     if (scale & 1)
  523.     return lastfdp->Width(ss, ll);
  524.     return sl;
  525. }
  526.  
  527. //---- device dependent methods ------------------------------------------------
  528.  
  529. void Port::DevClip(Rectangle)
  530. {
  531.     AbstractMethod("DevClip");
  532. }
  533.  
  534. void Port::DevFillRect(Rectangle*)
  535. {
  536.     AbstractMethod("DevFillRect");
  537. }
  538.  
  539. void Port::DevShowBitmap(Rectangle*, struct Bitmap*)
  540. {
  541.     AbstractMethod("DevShowBitmap");
  542. }
  543.  
  544. void Port::DevShowChar(Font*, Point, byte, Rectangle*)
  545. {
  546. }
  547.  
  548. void Port::DevShowTextBatch(Rectangle*, Point)
  549. {
  550.     AbstractMethod("DevShowTextBatch");
  551. }
  552.  
  553. void Port::DevGiveHint(int, int, void*)
  554. {
  555. }
  556.  
  557. void Port::DevSetPattern(struct DevBitmap*)
  558. {
  559. }
  560.  
  561. bool Port::DevSetColor(RGBColor *cp)
  562. {
  563.     cp->SetId(-1);
  564.     return TRUE;
  565. }
  566.  
  567. void Port::DevSetOther(int)
  568. {
  569. }
  570.  
  571. bool Port::DevImageCacheBegin(ImageCache*, Rectangle)
  572. {
  573.     return TRUE;    // need redraw
  574. }
  575.  
  576. void Port::DevImageCacheEnd(ImageCache*)
  577. {
  578. }
  579.  
  580. bool Port::DevScale(float ssx, float ssy)
  581. {
  582.     scalex= ssx;
  583.     scaley= ssy;
  584.     if (scalex != 1.0 || scaley != 1.0)
  585.     scale|= 1;
  586.     else
  587.     scale&= ~1;
  588.     return FALSE;   // FALSE means: can't scale
  589. }
  590.  
  591. void Port::DevShowPicture(Rectangle *r, Picture *pic)
  592. {
  593.     pic->Show(r, this);
  594. }
  595.  
  596. //---- window system independent graphic methods -------------------------------
  597.  
  598. Point Port::DevDrawArrow(int psz, Point s, Point e)
  599. {
  600.     int arrowwidth= Math::Max(6, psz*4+2), arrowlen= Math::Max(9, psz*7);
  601.     Point c, pts[3], ee(arrowwidth/2, arrowlen);
  602.     
  603.     if (Length(e-s) < arrowlen)
  604.     return e;     // too short, give up
  605.  
  606.     double ph= Phi(e-s), rot= Phi(ee), hyp= Length(ee);
  607.  
  608.     pts[0]= e;
  609. #ifdef PETERFIX
  610. // special case: going straight down
  611.     pts[1]= e + Point(-(arrowwidth/2),-arrowlen);
  612.     pts[2]= e + Point(arrowwidth/2,-arrowlen);
  613. #else
  614.     pts[1]= e + PolarToPoint(ph+rot, hyp, hyp);
  615.     pts[2]= e + PolarToPoint(ph-rot, hyp, hyp);
  616. #endif
  617.     c= Half(pts[1]+pts[2]);
  618.     
  619.     Rectangle rr= BoundingBox(3, pts);
  620.     DevFillPolygon2(&rr, pts, 3, ePolyDefault);
  621.     
  622.     return c;
  623. }
  624.  
  625. void Port::DevStrokeLine(int psz, Rectangle *r,
  626.                     GrLineCap cap, Point start, Point end)
  627. {
  628.     if (cap & eStartArrow)
  629.     start= DevDrawArrow(psz, end, start);
  630.     if (cap & eEndArrow)
  631.     end= DevDrawArrow(psz, start, end);
  632.     DevStrokeLine2(psz, r, cap, start, end);
  633. }
  634.  
  635. void Port::DevStrokeRect(int psz, Rectangle *r)
  636. {
  637.     int rpsz= (psz <= 0) ? 1 : psz;
  638.     
  639.     rpsz*= 2;
  640.     if (rpsz >= r->extent.x || rpsz >= r->extent.y)
  641.     DevFillRect(r);
  642.     else
  643.     DevStrokeRect2(psz, r);
  644. }
  645.  
  646. //---- splines -----------------------------------------------------------------
  647.  
  648. /*
  649.  * bez: Subdivide a Bezier spline, until it is thin enough to be
  650.  *      considered a line. Store line point in static array points.
  651. */
  652.  
  653. #define FIX(a) (((int) (a)) << 16)
  654. #define INT(a) (((a) + (1 << 15)) >> 16 )
  655. #define DELTA 1
  656.  
  657. static void bez(Point **gPp, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3)
  658. {
  659.     int maxx= Math::Max(x0, x3), minx= Math::Min(x0, x3), maxy= Math::Max(y0, y3), miny= Math::Min(y0, y3);
  660.     register int tx, ty;
  661.     
  662.     if (x1 >= minx && x1 <= maxx && y1 >= miny && y1 <= maxy
  663.         && x2 >= minx && x2 <= maxx && y2 >= miny && y2 <= maxy) {
  664.     register int ax, ay, dx= INT(x3-x0), dy= INT(y3-y0);
  665.     if (dx == 0 || dy == 0) {
  666.         (*gPp)->x= INT(x3);
  667.         (*gPp)++->y= INT(y3);
  668.         return;
  669.     }
  670.     ax= ((dy*INT(x1-x0))/dx)+INT(y0-y1);
  671.     ay= ((dx*INT(y1-y0))/dy)+INT(x0-x1);
  672.     if (Math::Abs(ax*ay) <= DELTA) {
  673.         (*gPp)->x= INT(x3);
  674.         (*gPp)++->y= INT(y3);
  675.         return;
  676.     }
  677.     ax= ((dy*INT(x2-x0))/dx)+INT(y0-y2);
  678.     ay= ((dx*INT(y2-y0))/dy)+INT(x0-x2);
  679.     if (Math::Abs(ax*ay) <= DELTA) {
  680.         (*gPp)->x= INT(x3);
  681.         (*gPp)++->y= INT(y3);
  682.         return;
  683.     }
  684.     }
  685.     
  686.     tx= (x0 >> 3) + 3 * (x1 >> 3) + 3 * (x2 >> 3) + (x3 >> 3);
  687.     ty= (y0 >> 3) + 3 * (y1 >> 3) + 3 * (y2 >> 3) + (y3 >> 3);
  688.     bez(gPp, x0, y0, (x0 >> 1) + (x1 >> 1), (y0 >> 1) + (y1 >> 1),
  689.         (x0 >> 2) + (x1 >> 1) + (x2 >> 2),
  690.         (y0 >> 2) + (y1 >> 1) + (y2 >> 2),
  691.         tx, ty);
  692.     bez(gPp, tx, ty, (x3 >> 2) + (x2 >> 1) + (x1 >> 2),
  693.         (y3 >> 2) + (y2 >> 1) + (y1 >> 2),
  694.         (x3 >> 1) + (x2 >> 1), (y3 >> 1) + (y2 >> 1),
  695.         x3, y3);
  696. }
  697.  
  698. static int makespline(Point *pts, Point *p, int n, GrPolyType)
  699. {
  700.     register int i;
  701.     Point *gPp= pts;
  702.     
  703.     gPp->x= p[0].x;
  704.     (gPp++)->y= p[0].y;
  705.     for (i= 0; i < n-1; i+= 3)
  706.     bez(&gPp, FIX(p[i+0].x), FIX(p[i+0].y), FIX(p[i+1].x), FIX(p[i+1].y),
  707.          FIX(p[i+2].x), FIX(p[i+2].y), FIX(p[i+3].x), FIX(p[i+3].y));
  708.     
  709.     return gPp - pts;
  710. }
  711.  
  712. void Port::DevStrokePolygon(Rectangle *r,
  713.         Point *pts, int npts, GrPolyType t, int psz, GrLineCap cap)
  714. {
  715.     Point *tmppts= 0;
  716.     
  717.     if (cap & eStartArrow)
  718.     DevDrawArrow(psz, pts[1]+r->origin, pts[0]+r->origin);
  719.     if (cap & eEndArrow)
  720.     DevDrawArrow(psz, pts[npts-2]+r->origin, pts[npts-1]+r->origin);
  721.     if (t & ePolyBezier) {
  722.     tmppts= (Point*) Alloca(sizeof(Point) * npts * 30);
  723.     int nn= makespline(tmppts, pts, npts, t);
  724.     if (nn > 0) {
  725.         pts= tmppts;
  726.         npts= nn;
  727.     }
  728.     }
  729.     DevStrokePolygon2(r, pts, npts, ePolyDefault, psz, cap);
  730.     Freea(tmppts);
  731. }
  732.  
  733. void Port::DevFillPolygon(Rectangle *r, Point *pts, int npts, GrPolyType t)
  734. {
  735.     Point *tmppts= 0;
  736.     if (t & ePolyBezier) {
  737.     tmppts= (Point*) Alloca(sizeof(Point) * npts * 30);
  738.     int nn= makespline(tmppts, pts, npts, t);
  739.     if (nn > 0) {
  740.         pts= tmppts;
  741.         npts= nn;
  742.     }
  743.     }
  744.     DevFillPolygon2(r, pts, npts, ePolyDefault);
  745.     Freea(tmppts);
  746. }
  747.  
  748. void Port::DevStrokeWedge(int psz, GrLineCap cap, Rectangle *r, int s, int d)
  749. {
  750.     int rpsz= (psz <= 0) ? 1 : psz;
  751.     rpsz*= 2;
  752.     if (rpsz >= r->extent.x || rpsz >= r->extent.y) {
  753.     DevFillWedge(r, s, d);
  754.     return;
  755.     }
  756.     if (r->extent.x < 4 || r->extent.y < 4) {
  757.     DevStrokeRect(psz, r);
  758.     return;
  759.     }
  760.     if (cap & eStartArrow) {
  761.     DevDrawArrow(psz, r->OvalAngleToPoint(s+10), r->OvalAngleToPoint(s));
  762.     // s+= 10; d-= 10;
  763.     }
  764.     if (cap & eEndArrow) {
  765.     DevDrawArrow(psz, r->OvalAngleToPoint(s+d-10), r->OvalAngleToPoint(s+d));
  766.     // d-= 10;
  767.     }
  768.     DevStrokeWedge2(psz, cap, r, s, d);
  769. }
  770.  
  771. void Port::DevFillWedge(Rectangle *r, int s, int d)
  772. {
  773.     if (r->extent.x < 4 || r->extent.y < 4)
  774.     DevFillRect(r);
  775.     else
  776.     DevFillWedge2(r, s, d);
  777. }
  778.  
  779. static void Wedge2Polygon(Point *pts, int &n, Point e2, float start, float len)
  780. {
  781.     if (len < 10)    // consider it a line
  782.     pts[n++]= PolarToPoint(start, e2.x, e2.y) + e2;
  783.     else {                  // subdivide
  784.     Wedge2Polygon(pts, n, e2, start, len/2);
  785.     Wedge2Polygon(pts, n, e2, start+len/2, len/2);
  786.     }
  787. }
  788.  
  789. void Port::DevStrokeWedge2(int psz, GrLineCap cap, Rectangle *r, int start, int len)
  790. {
  791.     Point *pts= (Point*) Alloca(sizeof(Point) * len);
  792.     Point e2= (r->extent-psz)/2;
  793.     int n= 0;
  794.  
  795.     Wedge2Polygon(pts, n, e2, start, len);
  796.     pts[n++]= PolarToPoint(start+len, e2.x, e2.y) + e2;
  797.     r->origin+= psz/2;
  798.     DevStrokePolygon2(r, pts, n, ePolyDefault, psz, cap);
  799.     Freea(pts);
  800. }
  801.  
  802. void Port::DevFillWedge2(Rectangle *r, int start, int len)
  803. {
  804.     Point *pts= (Point*) Alloca(sizeof(Point) * len);
  805.     Point e2= r->extent/2;
  806.     int n= 0;
  807.  
  808.     pts[n++]= e2;
  809.     Wedge2Polygon(pts, n, e2, start, len);
  810.     pts[n++]= PolarToPoint(start+len, e2.x, e2.y) + e2;
  811.     DevFillPolygon2(r, pts, n, ePolyDefault);
  812.     Freea(pts);
  813. }
  814.  
  815. void Port::DevStrokeRRect(int psz, Rectangle *r, Point dia)
  816. {
  817.     int rpsz= (psz <= 0) ? 1 : psz;
  818.     
  819.     rpsz*= 2;
  820.     if (rpsz >= r->extent.x || rpsz >= r->extent.y) {
  821.     DevFillRRect(r, dia);
  822.     return;
  823.     }
  824.     if (Math::Odd(dia.x))    // force to be even
  825.     dia.x--;
  826.     if (Math::Odd(dia.y))    // force to be even
  827.     dia.y--;
  828.     
  829.     if (dia.x >= r->extent.x && dia.y >= r->extent.y)
  830.     DevStrokeOval(psz, r);
  831.     else
  832.     DevStrokeRRect2(psz, r, Min(dia, r->extent));
  833. }
  834.  
  835. void Port::DevFillRRect(Rectangle *r, Point dia)
  836. {
  837.     if (Math::Odd(dia.x))    // force to be even
  838.     dia.x--;
  839.     if (Math::Odd(dia.y))    // force to be even
  840.     dia.y--;
  841.     
  842.     if (dia.x > r->extent.x && dia.y > r->extent.y)
  843.     DevFillOval(r);
  844.     else
  845.     DevFillRRect2(r, Min(dia, r->extent));
  846. }
  847.  
  848. void Port::DevStrokeOval(int psz, Rectangle *r)
  849. {
  850.     int rpsz= (psz <= 0) ? 1 : psz;
  851.     
  852.     rpsz*= 2;
  853.     if (rpsz >= r->extent.x || rpsz >= r->extent.y)
  854.     DevFillOval(r);
  855.     else if (r->extent.x < 4 || r->extent.y < 4)
  856.     DevStrokeRect(psz, r);
  857.     else
  858.     DevStrokeOval2(psz, r);
  859. }
  860.  
  861. void Port::DevFillOval(Rectangle *r)
  862. {
  863.     if (r->extent.x < 4 || r->extent.y < 4)
  864.     DevFillRect(r);
  865.     else
  866.     DevFillOval2(r);
  867. }
  868.  
  869. void Port::DevStrokeOval2(int psz, Rectangle *r)
  870. {
  871.     DevStrokeRRect2(psz, r, r->extent);
  872. }
  873.  
  874. void Port::DevFillOval2(Rectangle *r)
  875. {
  876.     DevFillRRect2(r, r->extent);
  877. }
  878.  
  879. //---- abstract methods --------------------------------------------------------
  880.  
  881. void Port::DevStrokeRect2(int, Rectangle*)
  882. {
  883.     AbstractMethod("DevStrokeRect2");
  884. }
  885.  
  886. void Port::DevStrokeRRect2(int, Rectangle*, Point)
  887. {
  888.     AbstractMethod("DevStrokeRRect2");
  889. }
  890.  
  891. void Port::DevFillRRect2(Rectangle*, Point)
  892. {
  893.     AbstractMethod("DevFillRRect2");
  894. }
  895.  
  896. void Port::DevStrokePolygon2(Rectangle*, Point*, int, GrPolyType, int, GrLineCap)
  897. {
  898.     AbstractMethod("DevStrokePolygon2");
  899. }
  900.  
  901. void Port::DevFillPolygon2(Rectangle*, Point*, int, GrPolyType)
  902. {
  903.     AbstractMethod("DevFillPolygon2");
  904. }
  905.  
  906. void Port::DevStrokeLine2(int, Rectangle*, GrLineCap, Point, Point)
  907. {
  908.     AbstractMethod("DevStrokeLine2");
  909. }
  910.  
  911. //---- Utilities ---------------------------------------------------------------
  912.  
  913. void DrawShadow(Rectangle &r, Point delta, Ink* fg, Ink *bg)
  914. {
  915.     if (delta != gPoint0) {
  916.     Rectangle sr(r);
  917.     sr.origin.x+= sr.extent.x;
  918.     sr.origin.y+= delta.y;
  919.     sr.extent.x= delta.x;
  920.     GrPaintRect(sr, bg);
  921.     sr= r;
  922.     sr.origin.x+= delta.x;
  923.     sr.origin.y+= sr.extent.y;
  924.     sr.extent.y= delta.y;
  925.     GrPaintRect(sr, bg);
  926.     }
  927.     GrPaintRect(r, fg);
  928.     GrStrokeRect(r);
  929. }
  930.    
  931.